﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace Webcam_Filter
{
    class OudeFotoFilter : Filter
    {
        protected override void runfilter(byte[] rgbValues, int hoogte, int breedte, string[] args)
        {

            

            int RandGrootte = 0;
            if (args.Length == 1 && args[0] != null)
                RandGrootte = int.Parse(args[0]);
            if (RandGrootte <= 0)
                RandGrootte = 16;

            int breedteARGB = ((breedte) * 4);

            int RandGrootteMax = ((RandGrootte) * 4);
            int blurSize = 2;

            int totaalAantalPixels = breedteARGB * hoogte;
           


            

            ///RAND

            for (int b = 0; b < breedteARGB - 3; b += 4)
            {
                for (int h = 0; h < RandGrootte; h++)
                {
                    rgbValues[(h * breedteARGB) + b] = 250;
                    rgbValues[(h * breedteARGB) + b + 1] = 245;
                    rgbValues[(h * breedteARGB) + b + 2] = 253;
                }

                for (int ho = hoogte - RandGrootte; ho < hoogte; ho++)
                {
                    rgbValues[(ho * breedteARGB) + b] = 250;
                    rgbValues[(ho * breedteARGB) + b + 1] = 245;
                    rgbValues[(ho * breedteARGB) + b + 2] = 253;
                }

                if (b < RandGrootteMax - 3)
                {
                    for (int he = 0; he < hoogte; he++)
                    {
                        rgbValues[(he * breedteARGB) + b] = 250;
                        rgbValues[(he * breedteARGB) + b + 1] = 245;
                        rgbValues[(he * breedteARGB) + b + 2] = 253;
                    }
                }

                if (b > breedteARGB - RandGrootteMax)
                {
                    for (int ha = 0; ha < hoogte; ha++)
                    {
                        rgbValues[(ha * breedteARGB) + b] = 250;
                        rgbValues[(ha * breedteARGB) + b + 1] = 245;
                        rgbValues[(ha * breedteARGB) + b + 2] = 253;
                    }
                }
            }






            

            //// BEGIN CODE VAN ROBIN
            int depth = 30;

            System.Random RandNum = new System.Random();
            int aantalLijnen = RandNum.Next(2);
            System.Threading.Thread.Sleep(RandNum.Next(100));

            int A, B, G, R;

            //sepia maken...

            for (int i = 0; i < breedteARGB * hoogte; i += 4)
            {
                B = rgbValues[i];
                G = rgbValues[i + 1];
                R = rgbValues[i + 2];
                A = rgbValues[i + 3];

                R = (int)((0.299 * R) + (0.587 * G) + (0.114 * B));
                G = B = R;

                R += (depth * 2);
                if (R > 255)
                {
                    R = 255;
                }
                G += depth;
                if (G > 255)
                {
                    G = 255;
                }

                rgbValues[i] = (byte)B;
                rgbValues[i + 1] = (byte)G;
                rgbValues[i + 2] = (byte)R;
            }

            ///EIND CODE VAN ROBIN


            
            





            


            ////// Blur 
            int blurSizeARGB = blurSize * 4;
            for (int h = 0; h < totaalAantalPixels; h += breedteARGB)
            {
                for (int b = h; b < h + breedteARGB; b += 4)
                {
                    int avgR = 0, avgG = 0, avgB = 0;
                    int blurPixelCount = 0;

                    
                    

                    int grensBytesHoogte = b + (blurSize * breedteARGB);
                    if (grensBytesHoogte > hoogte * breedteARGB)
                        grensBytesHoogte = hoogte * breedteARGB;

                    for (int hklein = b; hklein < grensBytesHoogte; hklein += breedteARGB)
                    {
                        int grensBytesBreedte = hklein + blurSizeARGB;
                        if (grensBytesBreedte > totaalAantalPixels)
                            grensBytesBreedte = totaalAantalPixels;

                        for (int bklein = hklein; bklein < grensBytesBreedte; bklein += 4)
                        {
                            blurPixelCount++;
                            avgB += rgbValues[bklein];
                            avgG += rgbValues[bklein + 1];
                            avgR += rgbValues[bklein + 2];
                        }
                    }

                    avgB /= blurPixelCount;
                    avgG /= blurPixelCount;
                    avgR /= blurPixelCount;


                    for (int hklein = b; hklein < grensBytesHoogte; hklein += breedteARGB)
                    {
                        int grensBytesBreedte = hklein + blurSizeARGB;
                        if (grensBytesBreedte > totaalAantalPixels)
                            grensBytesBreedte = totaalAantalPixels;

                        for (int bklein = hklein; bklein < grensBytesBreedte; bklein += 4)
                        {
                            rgbValues[bklein] = (byte)avgB;
                            rgbValues[bklein + 1] = (byte)avgG;
                            rgbValues[bklein + 2] = (byte)avgR;
                        }
                    }
                }
            }





            


        }
    }
}
